<?php
/**
 * Created by PhpStorm.
 * User: Drunk
 * Date: 16-12-7
 * Time: 下午4:25
 */

namespace drunk;

class structure {
    /**
     * 将结构队列树形化
     * @param array $items
     * @param mixed $pid
     * @param int $deep
     * @param string $key_primary
     * @param string $key_parent
     * @param bool $keepkey
     * @return array
     */
    public static function tree($items, $pid, $deep = 0, $key_primary = 'id', $key_parent = 'cid', $keepkey = false, $deep_current = 1){
        $items_peer = array();
        foreach( $items as $k=>$v ){
            if( $v[$key_parent] != $pid ) continue;
            unset($items[$k]);
            $children = !$deep || $deep_current < $deep
                ? self::tree($items, $v[$key_primary], $deep, $key_primary, $key_parent, $keepkey, $deep_current + 1)
                : 0;
            if( !empty($children) ) $v['children'] = $children;
            $keepkey ? $items_peer[$k] = $v : $items_peer[] = $v;
        }
        return $items_peer;
    }

    /**
     * 查询 参1 在 参2 数组元素中是否有相同值, 返回其在参2中的索引值集;
     * @param array $needle
     * @param array $haystack
     * @param bool $is_exists  是否仅检测其存在
     * @return int|array
     */
    public static function array_in_array($needle, $haystack, $is_exists = true){
        $item_haystack = current($haystack);
        if (empty($needle) || empty($item_haystack)) return false;
        $keys_intersect = array_keys($needle);
        $keys_haystack = array_keys($item_haystack);
        $keys_intersect = array_intersect($keys_intersect, $keys_haystack);
        $indexes = [];
        foreach($haystack as $k=>$item){
            foreach($keys_intersect as $key) if($needle[$key] != $item[$key]) continue 2;
            if($is_exists) return $k;
            $indexes[] = $k;
        }
        return empty($indexes) ? false : $indexes;
    }

    /**
     * 拆分解析字符串为主键与数组下标数组
     * @param string $key
     * @param string &$key_root
     * @param array &$key_array
     */
    public static function array_assign_key($key, &$key_root, &$key_array){
        $key = explode('.', $key);
        $key_array = array_slice($key, 1);
        $key_root = $key[0];
    }

    /**
     * 按结构数组下标对数组元素赋值
     * @param array $array
     * @param array $key_array
     * @param mixed $value
     * @return array|false
     */
    public static function array_assign($array, $key_array, $value){
        if (empty($key_array) || !is_array($key_array)) return false;
        $result = &$array;
        foreach ($key_array as $key) {
            if (!is_array($array)) return false; // 如果值非数组, 则无法设置子值, 返回假
            if (!array_key_exists($key, $array)) $array[$key] = []; // 如果无子值, 则初始化为数组
            $array = &$array[$key];
        }
        $array = $value;
        return $result;
    }

    /**
     * 按结构数组下标取数组元素
     * @param array $array
     * @param array $key_array
     * @return mixed
     */
    public static function array_assigned($array, $key_array){
        if (empty($key_array) || !is_array($key_array)) return null;
        foreach ($key_array as $key) {
            if (!is_array($array) || !array_key_exists($key, $array)) return null; // 如果值非数组或无子值, 则返回null
            $array = $array[$key];
        }
        return $array;
    }

    /**
     * 按结构数组下标删除数组元素
     * @param array $array
     * @param array $key_array
     * @return null|true
     */
    public static function array_assigned_delete(&$array, $key_array){
        if (empty($key_array) || !is_array($key_array)) return null;
        $k_last = count($key_array) - 1;
        foreach ($key_array as $k=>$key) {
            if (!is_array($array) || !array_key_exists($key, $array)) return null; // 如果值非数组或无子值, 则返回null
            if ($k_last === $k){
                unset($array[$key]);
                return true;
            }
            $array = &$array[$key];
        }
    }
}